HAL SMARTCARD I/O operations migration

This section provides information about the HAL SMARTCARD I/O operations migration.

Note

The processes for transmitting and receiving data using polling, interrupt, or DMA remain unchanged in HAL1 and HAL2.

Note

In both HAL1 and HAL2, the size parameter in the transmit and receive APIs represents the amount of data in bytes.

Process Polling

Function

HAL1 / HAL2

Transmit 

HAL1:  HAL_SMARTCARD_Transmit(SMARTCARD_HandleTypeDef *hsmartcard, const uint8_t *pData, uint16_t Size, uint32_t Timeout)
HAL2:  HAL_SMARTCARD_Transmit(hal_smartcard_handle_t *hsmartcard,  const uint8_t *p_data,uint16_t size_byte, uint32_t timeout_ms)

Receive 

HAL1:  HAL_SMARTCARD_Receive(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size, uint32_t Timeout)
HAL2:  HAL_SMARTCARD_Receive(hal_smartcard_handle_t *hsmartcard, uint8_t *p_data, uint16_t size_byte, uint32_t timeout_ms)

Related use cases: Use case: SMARTCARD communication in polling mode

Process IT

Function

HAL1 / HAL2

Transmit IT 

HAL1:  HAL_SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsmartcard, const uint8_t *pData, uint16_t Size)
HAL2:  HAL_SMARTCARD_Transmit_IT(hal_smartcard_handle_t *hsmartcard, const uint8_t *p_data, uint16_t size_byte)

Receive IT 

HAL1:  HAL_SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size)
HAL2:  HAL_SMARTCARD_Receive_IT(hal_smartcard_handle_t *hsmartcard, uint8_t *p_data, uint16_t size_byte)

Related use cases: Use case: SMARTCARD TX IT process and Use case: SMARTCARD RX IT process

Process DMA

Function

HAL1 / HAL2

Transmit DMA 

HAL1:  HAL_SMARTCARD_Transmit_DMA(SMARTCARD_HandleTypeDef *hsmartcard, const uint8_t *pData, uint16_t Size)
HAL2:  HAL_SMARTCARD_Transmit_DMA(hal_smartcard_handle_t *hsmartcard, const uint8_t *p_data, uint16_t size_byte)

Receive DMA 

HAL1:  HAL_SMARTCARD_Receive_DMA(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size)
HAL2:  HAL_SMARTCARD_Receive_DMA(hal_smartcard_handle_t *hsmartcard, uint8_t *p_data, uint16_t size_byte)

Related use cases: Use case: SMARTCARD TX DMA process and Use case: SMARTCARD RX DMA process

Transfer Abort

Function

HAL1 / HAL2

Abort 

HAL1:  HAL_SMARTCARD_Abort(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  HAL_SMARTCARD_Abort(hal_hsmartcard_handle_t *hsmartcard)

Abort Transmit 

HAL1:  HAL_SMARTCARD_AbortTransmit(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  Removed because TX and RX cannot run simultaneously. Use HAL_SMARTCARD_Abort() instead to abort the ongoing process (transmit or receive).

Abort Receive 

HAL1:  HAL_SMARTCARD_AbortReceive(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2: Removed because simultaneous abort of Tx and Rx is not supported. Use HAL_SMARTCARD_Abort() instead.

Abort IT 

HAL1:  HAL_SMARTCARD_Abort_IT(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  HAL_SMARTCARD_Abort_IT(hal_hsmartcard_handle_t *hsmartcard)

Abort Transmit IT 

HAL1:  HAL_SMARTCARD_AbortTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2: Removed because TX and RX cannot run simultaneously. Use HAL_SMARTCARD_Abort_IT() instead to abort the ongoing process (transmit or receive).

Abort Receive IT 

HAL1:  HAL_SMARTCARD_AbortReceive_IT(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2: Removed because TX and RX cannot run simultaneously. Use HAL_SMARTCARD_Abort_IT() instead to abort the ongoing process (transmit or receive).

IRQ Handler

Function

HAL1 / HAL2

IRQ Handler 

HAL1:  HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  HAL_SMARTCARD_IRQHandler(hal_hsmartcard_handle_t *hsmartcard)

Default Callbacks

Function

HAL1 / HAL2

TX Complete Callback 

HAL1:  HAL_SMARTCARD_TxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  HAL_SMARTCARD_TxCpltCallback(hal_smartcard_handle_t *hsmartcard)

RX Complete Callback 

HAL1:  HAL_SMARTCARD_RxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  HAL_SMARTCARD_RxCpltCallback(hal_smartcard_handle_t *hsmartcard)

Error Callback 

HAL1:  HAL_SMARTCARD_ErrorCallback(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  HAL_SMARTCARD_ErrorCallback(hal_smartcard_handle_t *hsmartcard)

Abort Complete Callback 

HAL1:  HAL_SMARTCARD_AbortCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  HAL_SMARTCARD_AbortCpltCallback(hal_smartcard_handle_t *hsmartcard)

RX FIFO Full Callback 

HAL1:  HAL_SMARTCARDEx_RxFifoFullCallback(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  HAL_SMARTCARD_RxFifoFullCallback(hal_smartcard_handle_t *hsmartcard)

TX FIFO Full Callback 

HAL1:  HAL_SMARTCARDEx_TxFifoEmptyCallback(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  HAL_SMARTCARD_TxFifoEmptyCallback(hal_smartcard_handle_t *hsmartcard)

Abort Transmit Complete Callback 

HAL1:  HAL_SMARTCARD_AbortTransmitCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  Removed because TX and RX cannot run simultaneously. Use HAL_SMARTCARD_AbortCpltCallback(hal_smartcard_handle_t *hsmartcard) instead

Abort Receive Complete Callback 

HAL1:  HAL_SMARTCARD_AbortReceiveCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard)
HAL2:  Removed because TX and RX cannot run simultaneously. Use HAL_SMARTCARD_AbortCpltCallback(hal_smartcard_handle_t *hsmartcard) instead

Note

The following two callbacks are added and available for DMA mode only: 

// Tx Half Complete Callback
HAL_SMARTCARD_TxHalfCpltCallback(hal_smartcard_handle_t *hsmartcard);

// Rx Half Complete Callback
HAL_SMARTCARD_RxHalfCpltCallback(hal_smartcard_handle_t *hsmartcard);

These callbacks notify the application when half of the data has been transmitted or received, enabling more efficient data handling .

Register Callbacks

HAL1

HAL2

In HAL1, the function HAL_SMARTCARD_RegisterCallback is used to register various SMARTCARD callbacks using a single function with a specific callback ID.

In HAL2, separate functions are available to register each specific SMARTCARD callback, providing more granularity and control over the callback registration process. 

// Register Tx Complete Callback
HAL_SMARTCARD_RegisterCallback(&hsmartcard,
                           HAL_SMARTCARD_TX_COMPLETE_CB_ID,
                           TxTransferCpltCallback);

// Register Rx Complete Callback
HAL_SMARTCARD_RegisterCallback(&hsmartcard,
                           HAL_SMARTCARD_RX_COMPLETE_CB_ID,
                           RxTransferCpltCallback);

// Register Error Callback
HAL_SMARTCARD_RegisterCallback(&hsmartcard,
                           HAL_SMARTCARD_ERROR_CB_ID,
                           ErrorCallback);

// Register Abort Complete Callback
HAL_SMARTCARD_RegisterCallback(&hsmartcard,
                           HAL_SMARTCARD_ABORT_COMPLETE_CB_ID,
                           AbortCpltCallback);

// Register Rx FIFO Full Callback
HAL_SMARTCARD_RegisterCallback(&hsmartcard,
                           HAL_SMARTCARD_RX_FIFO_FULL_CB_ID,
                           RxFifoFullCallback);

// Register Tx FIFO Empty Callback
HAL_SMARTCARD_RegisterCallback(&hsmartcard,
                           HAL_SMARTCARD_TX_FIFO_EMPTY_CB_ID,
                           TxFifoEmptyCallback);

// Register Abort Transmit Complete Callback
HAL_SMARTCARD_RegisterCallback(&hsmartcard,
                           HAL_SMARTCARD_ABORT_TRANSMIT_COMPLETE_CB_ID,
                           AbortTxCpltCallback);

// Register Abort Receive Complete Callback
HAL_SMARTCARD_RegisterCallback(&hsmartcard,
                           HAL_SMARTCARD_ABORT_RECEIVE_COMPLETE_CB_ID,
                           Abort RxCpltCallback);

// Register Tx Complete Callback
HAL_SMARTCARD_RegisterTxCpltCallback(&hsmartcard,
                                     TxTransferCpltCallback);


// Register Rx Complete Callback
HAL_SMARTCARD_RegisterRxCpltCallback(&hsmartcard,
                                     RxTransferCpltCallback);


// Register Error Callback
HAL_SMARTCARD_RegisterErrorCallback(&hsmartcard,
                                    ErrorCallback);


// Register Abort Complete Callback
HAL_SMARTCARD_RegisterAbortCpltCallback(&hsmartcard,
                                        AbortCpltCallback);


// Register Rx FIFO Full Callback
HAL_SMARTCARD_RegisterRxFifoFullCallback(&hsmartcard,
                                         RxFifoFullCallback);


// Register Tx FIFO Empty Callback
HAL_SMARTCARD_RegisterTxFifoEmptyCallback(&hsmartcard,
                                          TxFifoEmptyCallback);


// Register Abort Complete Callback
HAL_SMARTCARD_RegisterAbortCpltCallback(&hsmartcard,
                                        AbortCpltCallback);


// Register Abort Complete Callback
HAL_SMARTCARD_RegisterAbortCpltCallback(&hsmartcard,
                                        AbortCpltCallback);


**New callbacks:**

// Register Tx Half Complete Callback
HAL_SMARTCARD_RegisterTxHalfCpltCallback(&hsmartcard,
                                         TxHalfTransferCpltCallback);

// Register Rx Half Complete Callback
HAL_SMARTCARD_RegisterRxHalfCpltCallback(&uart_handle,
                                         RxHalfTransferCpltCallback);

Related concepts: Individual callback registration APIs replace global register and unregister functions

UnRegister Callbacks

In HAL2, the unregister callback API has been removed. Instead, users can manage callbacks by re-registering the default HAL SMARTCARD weak callbacks as needed.

HAL1

HAL2 

// Unregister Tx Complete Callback
HAL_SMARTCARD_UnRegisterCallback(&SMARTCARD_handle,
                                 HAL_SMARTCARD_TX_COMPLETE_CB_ID);

// Unregister Rx Complete Callback
HAL_SMARTCARD_UnRegisterCallback(&SMARTCARD_handle,
                                 HAL_SMARTCARD_RX_COMPLETE_CB_ID);

// Unregister Error Callback
HAL_SMARTCARD_UnRegisterCallback(&SMARTCARD_handle,
                                 HAL_SMARTCARD_ERROR_CB_ID);

// Unregister Abort Complete Callback
HAL_SMARTCARD_UnRegisterCallback(&SMARTCARD_handle,
                                 HAL_SMARTCARD_ABORT_COMPLETE_CB_ID);

// Unregister Rx FIFO Full Callback
HAL_SMARTCARD_UnRegisterCallback(&SMARTCARD_handle,
                                 HAL_SMARTCARD_RX_FIFO_FULL_CB_ID);

// Unregister Tx FIFO Empty Callback
HAL_SMARTCARD_UnRegisterCallback(&SMARTCARD_handle,
                                 HAL_SMARTCARD_TX_FIFO_EMPTY_CB_ID);

 // Unregister Abort Transmit Complete Callback
 HAL_SMARTCARD_UnRegisterCallback(&hsmartcard,
                                  HAL_SMARTCARD_ABORT_TRANSMIT_COMPLETE_CB_ID,
                                  AbortTxCpltCallback);

 // Unregister Abort Receive Complete Callback
 HAL_SMARTCARD_UnRegisterCallback(&hsmartcard,
                                  HAL_SMARTCARD_ABORT_RECEIVE_COMPLETE_CB_ID,
                                  AbortRxCpltCallback);

// Re-register default Tx Complete Callback
HAL_SMARTCARD_RegisterTxCpltCallback(&SMARTCARD_handle,
                                     HAL_SMARTCARD_TxCpltCallback);

// Re-register default Rx Complete Callback
HAL_SMARTCARD_RegisterRxCpltCallback(&SMARTCARD_handle,
                                     HAL_SMARTCARD_RxCpltCallback);

// Re-register default Error Callback
HAL_SMARTCARD_RegisterErrorCallback(&SMARTCARD_handle,
                                    HAL_SMARTCARD_ErrorCallback);

// Re-register default Abort Complete Callback
HAL_SMARTCARD_RegisterAbortCpltCallback(&SMARTCARD_handle,
                                        HAL_SMARTCARD_AbortCpltCallback);

// Re-register default RX fifo Complete Callback
HAL_SMARTCARD_RegisterRxFifoFullCallback(&SMARTCARD_handle,
                                        HAL_SMARTCARD_RxFifoFullCallback);

// Re-register default TX fifo Complete Callback
HAL_SMARTCARD_RegisterTxFifoEmptyCallback(&SMARTCARD_handle,
                                        HAL_SMARTCARD_TxFifoEmptyCallback);


// Re-register default Abort Complete Callback
HAL_SMARTCARD_RegisterAbortCpltCallback(&SMARTCARD_handle,
                                        HAL_SMARTCARD_AbortCpltCallback);



// Re-register default Abort Complete Callback
HAL_SMARTCARD_RegisterAbortCpltCallback(&SMARTCARD_handle,
                                        HAL_SMARTCARD_AbortCpltCallback);


 **New callbacks:**

// Re-register default Tx Half Complete Callback
HAL_SMARTCARD_RegisterTxHalfCpltCallback(&SMARTCARD_handle,
                                         HAL_SMARTCARD_TxHalfCpltCallback);

// Re-register default Rx Half Complete Callback
HAL_SMARTCARD_RegisterRxHalfCpltCallback(&SMARTCARD_handle,
                                         HAL_SMARTCARD_RxHalfCpltCallback);

Related concepts: Individual callback registration APIs replace global register and unregister functions